Qries eduard-martinez

Qries @emartigo

Qries https://eduard-martinez.github.io

1 R y Rstudio

R es el lenguaje de programación y el motor de cálculo; RStudio es la interfaz gráfica que facilita trabajar con ese motor.

R (motor de cálculo)

  • Se distribuye como software libre mantenido por el R Core Team.
  • Incluye el intérprete que ejecuta las instrucciones en R, las bibliotecas base y una consola mínima.
  • Puede utilizarse de forma autónoma desde la terminal o integrarse en servidores y procesos automatizados (por ejemplo, cron jobs o scripts de producción).

RStudio (IDE)

  • Constituye un entorno de desarrollo integrado (IDE) creado por Posit (antes RStudio PBC) y se instala después de R, al que usa como motor subyacente.
  • Aporta un editor con resaltado de sintaxis, autocompletado y depuración; paneles para el entorno de objetos, archivos, gráficos, paquetes y ayuda; además de integración con Git/GitHub.
  • Agiliza tareas comunes como la generación de documentos reproducibles (R Markdown/Quarto), el desarrollo de aplicaciones Shiny o la gestión de proyectos de análisis de datos, todo desde una única ventana gráfica.

1.1 Interfaz de R

La consola constituye el espacio donde se introducen instrucciones y se observa de inmediato el resultado de la evaluación. Cada línea comienza con el símbolo de promp >; al pulsar Enter se ejecuta la instrucción y, debajo, se imprime el valor devuelto o un mensaje de advertencia o error según corresponda. En la parte superior se visualiza el historial de comandos, lo que permite reutilizar expresiones previas mediante las flechas del teclado o la función history().

1.2 Interfaz RStudio

RStudio abre, por defecto, una ventana dividida en cuatro paneles principales, cada uno asociado a una fase del flujo de trabajo:

1.2.1 Consola (abajo a la izquierda)

  • Ejecuta las instrucciones procedentes del editor o las escritas directamente.
  • Muestra resultados, advertencias (Warning), mensajes (Message) y errores (Error).
  • Conserva el historial de comandos, accesible con las flechas ↑/↓ o con history().

1.2.2 Entorno / Historial (arriba a la derecha)

  • Environment registra los objetos creados durante la sesión (data frames, funciones, listas, etc.).
  • History conserva la secuencia de comandos ejecutados; desde allí pueden reenviarse a la consola o guardarse en un script.

1.2.3 Panel inferior (abajo a la derecha) — pestañas modulares

  • Files: navegación por el sistema de archivos del proyecto.
  • Plots: vista preliminar de gráficos generados (con opciones de exportación).
  • Packages: listado de bibliotecas instaladas y herramienta de actualización.
  • Help: documentación contextual (?función) y viñetas (vignette()).
  • Viewer: salida de aplicaciones Shiny, documentos HTML o visualizaciones interactivas.
  • Git / Terminal (si procede): integración con control de versiones y acceso a la línea de comandos.

1.2.4 Editor de scripts (arriba a la izquierda)

  • Permite redactar archivos R, R Markdown, Quarto, SQL, Python, etc.
  • Incluye resaltado de sintaxis, autocompletado, sangrado automático y marcadores.
  • El código seleccionado se envía a la consola con Ctrl + Enter; el script completo se ejecuta con Ctrl + Shift + S o mediante el botón Source.

2 Primeros pasos en R

Antes de crear objetos, conviene repasar las operaciones básicas y la forma de visualizar resultados en la consola. R permite realizar cálculos aritméticos, evaluaciones lógicas y comparaciones con una sintaxis simple y reglas de precedencia estándar. En esta sección se presentan estos operadores y ejemplos mínimos para interpretar correctamente la salida.

2.1 Operaciones aritméticas

Se utilizan los operadores aritméticos estándar para sumar, restar, multiplicar, dividir y elevar potencias.

Operador Descripción Ejemplo
+ Suma 3 + 2
- Resta 7 - 4
* Multiplicación 6 * 3
/ División 8 / 2
^, ** Exponenciación 2^3
%% Módulo (resto de división) 10 %% 3
%/% División entera 10 %/% 3

Ejemplo de operaciones básicas:

1 + 2  # Suma
[1] 3
5 / 2  # División
[1] 2.5
100 %/% 60  # ¿Cuántas horas enteras hay en 100 minutos?
[1] 1
100 %% 60   # ¿Cuántos minutos quedan?
[1] 40

Por defecto, R evalúa siguiendo estas reglas de precedencia (de mayor a menor):

1.  ^  →  2) * y /  →  3) + y -.

Cuando se desea alterar este orden, conviene usar paréntesis para hacer explícita la intención y evitar ambigüedades. En expresiones largas, es buena práctica comentar el resultado esperado al final de la línea.+y-` (suma y resta)

3 + 2 * 4  # Multiplicación antes de la suma (resultado: 11)
[1] 11
(3 + 2) * 4  # Uso de paréntesis para cambiar precedencia (resultado: 20)
[1] 20

2.2 Operadores lógicos

R incluye operadores lógicos elemento a elemento. Úsalos para filtrar, combinar condiciones y construir expresiones.

Operador Descripción Ejemplo
< , > Menor y mayor que 5 > 3
<= , >= Menor o igual y mayor igual que 5 >= 5E
== Igual a 3 == 3
!= Diferente de 3 != 4
& y (AND lógico) TRUE & FALSE
| o (OR lógico) TRUE | FALSE
! Negación lógica !TRUE

Ejemplos rápidos:

1 > 2            # ¿Es 1 mayor que 2?
[1] FALSE
1 > 2 & 1 > 0.5  # ¿Es 1 mayor que 2 y mayor que 0.5?
[1] FALSE
1 > 2 | 1 > 0.5  # ¿Es 1 mayor que 2 o mayor que 0.5?
[1] TRUE
isTRUE(1 < 2)    # TRUE (solo TRUE exacto; NA o 1 no pasan)
[1] TRUE

Precaución con la precedencia: Los operadores relacionales (>, <, ==) se evalúan antes que (&, |) ya que tiene precedencia alta.

1 > 0.5 & 2  # ¿Qué pasa aquí?
[1] TRUE

Para evitar confusión, siempre compare valores explícitamente:

1 > 0.5 & 1 > 2  # Evaluación correcta
[1] FALSE

2.3 Evaluación de pertenencia con %in%

%in% verifica si cada elemento del lado izquierdo pertenece al conjunto del lado derecho. Es vectorizado y la forma preferida para “está en…”.

4 %in% 1:10  # ¿Está 4 en la secuencia del 1 al 10?
[1] TRUE
4 %in% 5:10  # ¿Está 4 en la secuencia del 5 al 10?
[1] FALSE
c(4, 11) %in% 1:10
[1]  TRUE FALSE

También podemos evaluar igualdad con ==. Sin embargo, == compara posición a posición y puede reciclar vectores (riesgo de errores). Para “pertenece a uno de varios valores”, usa %in%.

1:6 == 4         # compara contra un escalar -> c(FALSE,FALSE,FALSE,TRUE,FALSE,FALSE)
[1] FALSE FALSE FALSE  TRUE FALSE FALSE
1:6 == c(4,5)    # recicla: compara por posición (cuidado)
[1] FALSE FALSE FALSE FALSE FALSE FALSE
1:6 %in% c(4,5)  # forma correcta para pertenencia múltiple
[1] FALSE FALSE FALSE  TRUE  TRUE FALSE

3 Tipos de datos básicos

En R trabajamos con valores que pertenecen a categorías básicas. Por ahora usaremos tres grandes grupos: numéricos, texto y lógicos. Además, verás algunos valores especiales que aparecen en cálculos.

3.1 Numéricos

Incluyen enteros y números reales (decimales). Se pueden escribir en notación usual o científica.

10        # entero (R lo maneja como numérico)
[1] 10
3.14      # decimal
[1] 3.14
1e6       # notación científica: 1 * 10^6
[1] 1e+06

3.2 Texto (cadenas de caracteres)

Las cadenas se escriben entre comillas simples o dobles. Ambas funcionan igual; solo asegúrate de abrir y cerrar con el mismo tipo. Para incluir comillas dentro de una cadena, escápalas con . Las cadenas admiten secuencias de escape útiles como (salto de línea) y tabulación). R maneja bien acentos y eñes si tu archivo está en UTF-8.

"Hola mundo"
[1] "Hola mundo"
"Comillas \"dentro\" de comillas"
[1] "Comillas \"dentro\" de comillas"
'Líneas:\nPrimera\nSegunda'   # '\n' se interpreta como salto de línea
[1] "Líneas:\nPrimera\nSegunda"

3.3 Lógicos

Los valores lógicos representan verdadero o falso y no llevan comillas: se escriben TRUE y FALSE (en mayúsculas). Evita T y F porque son nombres de objetos y podrían estar redefinidos. El operador ! niega, & es AND y | es OR. Ten en cuenta que & y | operan elemento a elemento, mientras que && y || evalúan solo el primer elemento (algo útil cuando trabajes con condiciones escalares).

TRUE
FALSE
!TRUE          # negación
TRUE & FALSE   # AND
TRUE | FALSE   # OR

Dato útil: en operaciones aritméticas, TRUE se comporta como 1 y FALSE como 0. (Esto permite contar condiciones más adelante, sin introducir funciones por ahora.)

3.4 Valores especiales

Al calcular en R pueden aparecer valores especiales que conviene identificar: NA, que representa un dato faltante o desconocido y puede darse en cualquier tipo; Inf y -Inf, que indican infinitos (por ejemplo, al dividir por cero con numerador no nulo); NaN, que señala un resultado indeterminado o “no numérico” (como 0/0); y NULL, que denota ausencia de valor u objeto y no es equivalente a NA.

NA    # dato faltante
Inf   # infinito
-Inf  # menos infinito
NaN   # indeterminado
NULL  # ausencia de valor

¿Cómo suelen aparecer?

1/0      # Inf
[1] Inf
-1/0     # -Inf
[1] -Inf
0/0      # NaN
[1] NaN
1 + NA   # NA (cualquier operación con NA suele dar NA)
[1] NA

Diferencias clave: NA indica que hay un lugar para un valor, pero no sabemos cuál es; NULL significa que no hay valor (ausencia total); NaN corresponde a un resultado indeterminado de una operación numérica; y Inf/-Inf representan resultados no acotados que crecen sin límite.

4 Resultados de la Consola

Cuando R está listo para ejecutar una instrucción, muestra el prompt >. Si al presionar Enter la instrucción quedó incompleta (p. ej., paréntesis o comillas sin cerrar, o un operador al final de la línea), R cambia al prompt de continuación +, indicando que espera que completes lo que falta. Ejemplos que provocan + (no se ejecutan, solo ilustran):

> (1 + 2        # falta cerrar el paréntesis
+  "hola        # falta cerrar la comilla

Para volver al > se debe completar lo pendiente y presiona Enter o cancelar la entrada actual con Esc (en RStudio.

4.1 ¿Qué se imprime en la consola?

Cada expresión evaluada puede producir uno de estos resultados:

  • Resultado normal (sin problemas): R imprime el valor calculado.
  • Mensaje (message): Información útil que no interrumpe la ejecución.
  • Advertencia (warning): Algo no ideal ocurrió, pero la ejecución continúa (suele indicar conversiones o valores indefinidos).
  • Error (error): Un problema crítico detiene la ejecución.
1 + 2
[1] 3
2 + "2"
Error in 2 + "2": non-numeric argument to binary operator

Resumen rápido:

•   ">" listo para ejecutar; "+" esperando que completes una instrucción.
•   Resultado: valor calculado.
•   Message: información; no detiene.
•   Warning: posible problema; no detiene.
•   Error: detiene la ejecución.
•   En Rmd: usa message=FALSE, warning=FALSE, error=TRUE con criterio.

5 Librerías y Funciones

5.1 Librerías:

Una librería (paquete) es un conjunto de funciones, datos y documentación pensadas para resolver tareas específicas (p. ej., tidyverse para manipulación/visualización, rio para importación/exportación).

  • Instalar: solo una vez por equipo/versión de R → install.packages()
  • Cargar (adjuntar): en cada sesión donde la uses → library() o require()
  • Actualizar: cuando haya versiones nuevas → update.packages()
install.packages("tidyverse")
install.packages(c("skimr","rio"))

Nota: library("pkg") lanza error si al llamar la librería no está instalada. require("pkg") devuelve TRUE/FALSE; si no está, pero no detiene el script.

library(tidyverse)
require(skimr)

Nota: puede inspeccionar las librerías que tiene activas en su sesión corriendo la función sessionInfo() sobre la consola de R. Cuando inicia sesión, R carga 7 librerías bases (usted,stats,graphics,grDevices,utils, datasets, methods y base). Pero usted puede instalar/llamar cerca de 22498 librerías disponibles en el CRAN de R.

sessionInfo()

5.2 Funciones y help

Una función permite crear, editar, transformar o eliminar objetos. Están contenidas en librerías. Y cada función contiene por lo menos 1 argumento.

NOTA: Toda función abre con ( y debe cerrar con un ). Aseguresé de ejecutar la función así, para que R entienda hasta que punto debe ejecutar esa funcíon.

5.2.1 Obtener ayuda de una función

En R, la documentación integrada es el primer recurso para entender qué hace una función, qué argumentos acepta y qué devuelve. Se recomienda consultar la ayuda antes de probar “a ciegas”. Para obtener más información sobre una función u objeto (con nombre) en R, consulte la documentación de “help” o usando ?:

help(rnorm)
?rnorm

Hint: ¿Ves la sección Ejemplos en la parte inferior del archivo de ayuda? Puedes ejecutarlos con la función example().

example(rnorm)

Las secciones más útiles son:

  • Description: qué hace.
  • Usage: la “firma” de la función.
  • Arguments: qué recibe (y qué tipo).
  • Value: qué devuelve.
  • Examples: casos ejecutables.
  • See Also: funciones relacionadas.

5.2.2 Argumentos de una función

Para inspeccionar los argumentos de una función y sus valores por defecto. args(rnorm) muestra los nombres y el orden de los argumentos que la función espera; para rnorm se verá algo como function (n, mean = 0, sd =1), lo que indica que n no tiene valor por defecto (es obligatorio) y que mean y sd por defecto son 0 y 1. formals(rnorm) devuelve una lista con los argumentos formales y sus valores por defecto; allí mean = 0 y sd = 1, mientras que n aparece sin valor (obligatorio). Esto ayuda a llamar funciones de forma segura (por nombre o por posición) y a cambiar solo lo necesario.

args(rnorm)        # nombres y orden de argumentos
function (n, mean = 0, sd = 1) 
NULL
formals(rnorm)     # valores por defecto
$n


$mean
[1] 0

$sd
[1] 1

Cuando se usa los argumentos por posición se depende estrictamente del orden definido en la firma de la función (por ejemplo, rnorm(n, mean = 0, sd = 1)), de modo que un intercambio accidental puede generar una media o desviación equivocadas sin lanzar error. Al usar argumentos con nombre (n =, mean =, sd =), el código queda autoexplicativo, tolera el reordenamiento y resulta más robusto cuando se añaden parámetros opcionales; como regla práctica, suele recomendarse nombrar los argumentos no obvios y, si se desea, dejar por posición únicamente los indispensables (p. ej., n).

rnorm(n = 5, mean = 10, sd = 2)  # por nombre (más claro)
[1]  7.926463 12.554947  7.625964 11.677084 12.511610
rnorm(5, 10, 2)                  # por posición (equivalente)
[1] 13.091666  6.180593 11.227761  9.493991 12.299233

5.2.3 Vignettes

Para muchos paquetes, también puede probar la función vignette(), que proporcionará una introducción a un paquete y su propósito a través de una serie de ejemplos útiles. Una complicación es que necesita saber el nombre exacto de la(s) viñeta(s) del paquete. Intente ejecutar:

vignette("base")

5.2.4 Demos

Al igual que las viñetas, muchos paquetes vienen con demostraciones interactivas integradas. Para enumerar todas las demostraciones disponibles en su sistema:

demo("graphics", package = "graphics")
demo(package = .packages(all.available = TRUE))

6 Orientado a objetos

En R todo se maneja como objetos a los que se les asigna un nombre en el espacio de trabajo (environment). Un objeto puede ser vector, matriz, data frame, lista o incluso una función, y su clase determinan qué operaciones son válidas y cómo se comporta. La asignación simplemente vincula un nombre con un valor (resultado de una expresión o función). Luego, los objetos pueden inspeccionarse, indexarse, convertirse entre formas compatibles (p. ej., de data frame a matriz) y reutilizarse en nuevos cálculos. En análisis reproducible conviene usar nombres claros y consistentes, y evitar palabras reservadas para no interferir con el lenguaje.

6.1 Asignar objetos

Para asignar un objeto se debe seguir la siguiente estructura:

nombre_objeto + asignar + funcion()

# Una forma de hacerlo: 
data_1 <- rnorm(n = 10 , mean = 50 , sd = 10)

# Otra forma de hacerlo: 
data_2 = rnorm(n = 10 , mean = 40 , sd = 10)

¿Qué operador de asignación usar?

La mayoría de los usuarios de R (¿puristas?) parecen preferir <- para la asignación, ya que = también tiene un papel específico para la evaluación dentro de las funciones.

  • Veremos muchos ejemplos de esto más adelante.

  • Pero no creo que importe; = es más rápido de escribir y es más intuitivo si vienes de otro lenguaje de programación. (Más discusión aquí)

Conclusión: Usa lo que prefieras. Solo sé consistente dentro de tu propio código. i.e: Usa el mismo operador en la medida de lo posible.

También puede asignar objetos usando la siguiente estructura:

x1 <- 2 + 2
x1
## [1] 4
assign("x2", 3/6)
x2
## [1] 0.5
3*4 -> x3
x3
## [1] 12

6.2 ¿Qué es un objeto?

Es importante enfatizar que hay muchos tipos (o clases) diferentes de objetos.

Volveremos a examinar el tema de “tipo” frente a “clase” en una o dos diapositivas. Por el momento, es útil simplemente nombrar algunos objetos con los que trabajaremos regularmente:

  • vectores
  • matrices
  • dataframes
  • listas
  • funciones
  • etc.

Cada clase de objeto tiene su propio conjunto de reglas (“métodos”) para determinar operaciones válidas. Por ejemplo, aunque hay operaciones que funcionan en matrices y dataframes, también hay algunas operaciones que solo funcionan en una matriz, y viceversa. Al mismo tiempo, puede (generalmente) convertir un objeto de un tipo a otro.

## Crea un dataframe llamado "df".
df = data.frame(x = 1:2, y = 3:4)
df
##   x y
## 1 1 3
## 2 2 4
## Convertirlo en una matriz "mt".
mt = as.matrix(df)
mt

Puede inspeccionar/imprimir un objeto directamente en la consola debe escribir df en la consola o puede usar la función View(df) para verlo en el editor de datos.

6.3 Clase, tipo y estructura

Usar class, typeof, y str para conocer más acerca de un objeto.

class(df) ## Evaluate its class.
[1] "data.frame"
typeof(df) ## Evaluate its type.
[1] "list"
str(df) ## Show its structure.
'data.frame':   2 obs. of  2 variables:
 $ x: int  1 2
 $ y: int  3 4

6.4 Todo tiene un ‘nombre’

Podemos asignar objetos a diferentes nombres. Sin embargo, hay una serie de palabras especiales que están “reservadas” en R. Estos son comandos, operadores y relaciones fundamentales en base R que no se pueden (re)asignar (aunque se quisiera). Consulte una lista completa aquí.

Algunas de las palabras que no se pueden usar:

if 
else 
while 
function 
for
TRUE 
FALSE 
NULL 
Inf 
NaN 
NA

Además de la lista de palabras estrictamente reservadas, existe otro conjunto de palabras que, aunque se reasignar pero que es mejor no usarlas.

Por ejemplo: c() se usa para concatenar; es decir, crear vectores y unir diferentes objetos.

c <- 4
c(1, 2, 5)

Afortunadamente nada. R es lo suficientemente “inteligente” para distinguir entre la variable c <- 4 que creamos y la función integrada c() que requiere concatenación.

¿Qué pasa si usamos comillas para nombrar un objeto?

"hola" <- 2
hola

7 ¿Workspace?

El workspace (o Global Environment) es la colección de objetos que viven en la memoria de la sesión actual de R. Allí se guardan los resultados que vas creando (vectores, data frames, modelos, funciones…). Al cerrar R, ese contenido se pierde salvo que se guarde explícitamente.

objects()           # o ls(): lista de nombres de objetos
## [1] "df"     "my_tbl" "x1"     "x2"     "x3"
ls()
## [1] "df"     "my_tbl" "x1"     "x2"     "x3"
ls.str()            # lista + mini estructura (útil para inspección rápida)
## df : 'data.frame':   2 obs. of  2 variables:
##  $ x: int  1 2
##  $ y: int  3 4
## my_tbl : tibble [7 × 3] (S3: tbl_df/tbl/data.frame)
## x1 :  num 4
## x2 :  num 0.5
## x3 :  num 12
object.size(mtcars) # tamaño (bytes) de un objeto
## 7208 bytes

Para realizar tareas de “limpieza”: rm() elimina objetos del workspace, pero sin nombres no borra nada; lo habitual es usar rm(x, y) para quitar objetos concretos. rm(list = ls()) vacía por completo el entorno global (operación destructiva: se pierden todos los objetos de la sesión), por lo que en material reproducible conviene marcarlo con eval = FALSE y usarlo solo de forma consciente. Por último, cat("\f") (form feed) limpia la consola de RStudio —solo la pantalla—, sin afectar a los objetos en memoria.

rm()          # remover un objeto del espacio de trabajo
rm(list=ls()) # Limpiar el entorno de trabajo
cat("\f")     # Limpiar la consola

8 Vectores y matrices

Los vectores y las matrices son objetos homogéneos. Es decir, todos los elementos de estos objeto deben ser del mismo tipo (numérico o carácter o lógico). Sim embargo, mientras los vectores son de una dimensión las matrices tienen dos dimensiones (filas y columnas).

8.1 Vectores

8.1.1 Indexación

La indexación en R comienza en 1. No 0 como en algunos lenguajes (por ejemplo, Python y JavaScript). Podemos usar [] para indexar objetos que creamos en R.

a <- c(10 , 20 , 30 , 40 , 50 , 60)
a[4]   # obtener el cuarto elemento del objeto "a"
[1] 40
a[2:3] # maneter elementos de la posición 2 a la 3
[1] 20 30
a[-3]  # eliminar el tercer elemento
[1] 10 20 40 50 60

8.1.2 Extraer valores

Usando operadores lógicos o aritméticos

x <- c(NA,1,2,3,4,5,NA)
x[!is.na(x)]  # Diferentes de NA
## [1] 1 2 3 4 5
x[x>3]        # Mayores a 3 (Ojo con los NA)
## [1] NA  4  5 NA
x[x %in% 1:3] # Contenidos en 1 a 3
## [1] 1 2 3

8.1.3 Operar sobre vectores

x <- 1:5
length(x) # largo del vector
## [1] 5

Algunos operadores que se pueden aplicar: +, -, *, /, ^, sum(), mean(), min()…

sum(x) ; length(x) ; prod(x) ; mean(x)
## [1] 15
## [1] 5
## [1] 120
## [1] 3

8.2 Matrices

Una matriz en R es un objeto homogéneo de dos dimensiones (todas sus celdas son del mismo tipo), esencialmente un vector al que se le añade el atributo dim. Se construye con matrix() indicando datos y dimensiones, y se llena por columnas de forma predeterminada (puede cambiarse con byrow = TRUE). Se accede con índice [i, j] (filas, columnas), y como cualquier objeto en R puedes inspeccionarla con attributes(), class() y str(). La sustitución de valores funciona muy bien con indexación lógica (p. ej., asignar NA a todos los elementos < 4).

x = matrix(data = 1:9 , nrow=3 , ncol=3)
x
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9

8.2.1 Atributos

attributes(x) # atributos
## $dim
## [1] 3 3
class(x)      # clase
## [1] "matrix" "array"
str(x)        # tipo de dato
##  int [1:3, 1:3] 1 2 3 4 5 6 7 8 9

8.2.2 Indexación

x[1,]  # Obtener la fila 1
## [1] 1 4 7
x[,3]  # Obtener la columna 3
## [1] 7 8 9
x[2,2] # Obtener elemento de la fila y columna 2
## [1] 5

8.2.3 Reemplazar valores

x[x<4] = NA
x
##      [,1] [,2] [,3]
## [1,]   NA    4    7
## [2,]   NA    5    8
## [3,]   NA    6    9

9 Dataframes

Un data frame es una tabla de dos dimensiones (filas = observaciones, columnas = variables) donde cada columna es un vector del mismo largo y, por tanto, tiene un único tipo (numérico, carácter, lógico…), pero distintas columnas pueden tener tipos diferentes. Es la estructura base para manejar datos tabulares en R. Conjuntos de datos disponibles en memoria:

## Chequear librerías
data(package="datasets")
df <- datasets::mtcars  # 'mtcars' ya es un data frame
head(df)                # imprimir las primeras filas
##                    mpg cyl disp  hp drat    wt  qsec vs am gear carb
## Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
## Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
## Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
## Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
## Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
## Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1
class(df)               # clase del objeto
## [1] "data.frame"
dim(df)                 # filas y columnas
## [1] 32 11
colnames(df)            # nombres de variables
##  [1] "mpg"  "cyl"  "disp" "hp"   "drat" "wt"   "qsec" "vs"   "am"   "gear"
## [11] "carb"
str(df)                 # estructura: tipos de columnas y muestra de valores
## 'data.frame':    32 obs. of  11 variables:
##  $ mpg : num  21 21 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 ...
##  $ cyl : num  6 6 4 6 8 6 8 4 4 6 ...
##  $ disp: num  160 160 108 258 360 ...
##  $ hp  : num  110 110 93 110 175 105 245 62 95 123 ...
##  $ drat: num  3.9 3.9 3.85 3.08 3.15 2.76 3.21 3.69 3.92 3.92 ...
##  $ wt  : num  2.62 2.88 2.32 3.21 3.44 ...
##  $ qsec: num  16.5 17 18.6 19.4 17 ...
##  $ vs  : num  0 0 1 1 0 1 0 1 1 1 ...
##  $ am  : num  1 1 1 0 0 0 0 0 0 0 ...
##  $ gear: num  4 4 4 3 3 3 3 4 4 4 ...
##  $ carb: num  4 4 1 1 2 1 4 2 2 4 ...

9.1 Atributos un dataframe

colnames(df)   # acceder a los nombres de las variables/columnas
##  [1] "mpg"  "cyl"  "disp" "hp"   "drat" "wt"   "qsec" "vs"   "am"   "gear"
## [11] "carb"
attributes(df) # Ver atributos
## $names
##  [1] "mpg"  "cyl"  "disp" "hp"   "drat" "wt"   "qsec" "vs"   "am"   "gear"
## [11] "carb"
## 
## $row.names
##  [1] "Mazda RX4"           "Mazda RX4 Wag"       "Datsun 710"         
##  [4] "Hornet 4 Drive"      "Hornet Sportabout"   "Valiant"            
##  [7] "Duster 360"          "Merc 240D"           "Merc 230"           
## [10] "Merc 280"            "Merc 280C"           "Merc 450SE"         
## [13] "Merc 450SL"          "Merc 450SLC"         "Cadillac Fleetwood" 
## [16] "Lincoln Continental" "Chrysler Imperial"   "Fiat 128"           
## [19] "Honda Civic"         "Toyota Corolla"      "Toyota Corona"      
## [22] "Dodge Challenger"    "AMC Javelin"         "Camaro Z28"         
## [25] "Pontiac Firebird"    "Fiat X1-9"           "Porsche 914-2"      
## [28] "Lotus Europa"        "Ford Pantera L"      "Ferrari Dino"       
## [31] "Maserati Bora"       "Volvo 142E"         
## 
## $class
## [1] "data.frame"
dim(df) # dimensiones
## [1] 32 11
str(df) # Estructura
## 'data.frame':    32 obs. of  11 variables:
##  $ mpg : num  21 21 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 ...
##  $ cyl : num  6 6 4 6 8 6 8 4 4 6 ...
##  $ disp: num  160 160 108 258 360 ...
##  $ hp  : num  110 110 93 110 175 105 245 62 95 123 ...
##  $ drat: num  3.9 3.9 3.85 3.08 3.15 2.76 3.21 3.69 3.92 3.92 ...
##  $ wt  : num  2.62 2.88 2.32 3.21 3.44 ...
##  $ qsec: num  16.5 17 18.6 19.4 17 ...
##  $ vs  : num  0 0 1 1 0 1 0 1 1 1 ...
##  $ am  : num  1 1 1 0 0 0 0 0 0 0 ...
##  $ gear: num  4 4 4 3 3 3 3 4 4 4 ...
##  $ carb: num  4 4 1 1 2 1 4 2 2 4 ...

9.2 Indexación

Los dataframes tienen dos dimensiones [i,j], siendo i y j la la i-ésima fila y j-ésima la columna respectivamente.

df[1,]  # Obtener la fila 1
##           mpg cyl disp  hp drat   wt  qsec vs am gear carb
## Mazda RX4  21   6  160 110  3.9 2.62 16.46  0  1    4    4
df[,3]  # Obtener la columna 3
##  [1] 160.0 160.0 108.0 258.0 360.0 225.0 360.0 146.7 140.8 167.6 167.6 275.8
## [13] 275.8 275.8 472.0 460.0 440.0  78.7  75.7  71.1 120.1 318.0 304.0 350.0
## [25] 400.0  79.0 120.3  95.1 351.0 145.0 301.0 121.0
df[1:3,1:4] # Acceder a las primeras 4 filas/columnas
##                mpg cyl disp  hp
## Mazda RX4     21.0   6  160 110
## Mazda RX4 Wag 21.0   6  160 110
## Datsun 710    22.8   4  108  93
df[2,2] # Obtener elemento de la fila y columa 2
## [1] 6
df$wt       # Acceder a la variable wt
##  [1] 2.620 2.875 2.320 3.215 3.440 3.460 3.570 3.190 3.150 3.440 3.440 4.070
## [13] 3.730 3.780 5.250 5.424 5.345 2.200 1.615 1.835 2.465 3.520 3.435 3.840
## [25] 3.845 1.935 2.140 1.513 3.170 2.770 3.570 2.780

9.3 tibble() o data.frame()

Un tibble (paquete tibble, parte del tidyverse) es una variante moderna del data.frame. Conserva lo esencial para datos tabulares y cambia comportamientos que suelen causar errores en principiantes: impresión más segura, subsetting estable por tipo, reglas estrictas de reciclado y sin coincidencia parcial de nombres. (Históricamente, además, nunca convertía caracteres en factores; desde R ≥ 4.0, data.frame() tampoco lo hace por defecto).

  • Impresión: tibble imprime pocas filas/columnas y muestra el tipo de cada variable; data.frame intenta imprimir todo.
  • Subsetting: con [ un tibble siempre devuelve otro tibble (no “colapsa” a vector); en data.frame [ puede soltar la dimensión (drop) si seleccionas 1 columna.
  • Reciclado al crear/añadir columnas: tibble permite longitud 1 o exactamente n filas; si no, error. data.frame puede reciclar y hasta emitir advertencias difíciles de notar.
  • Nombres y coincidencia parcial: tibble no hace coincidencia parcial con $ o [[; data.frame puede hacerlo, provocando errores silenciosos.
require(tibble)
tb <- as_tibble(mtcars)     # convertir a tibble
class(tb)
## [1] "tbl_df"     "tbl"        "data.frame"
df <- as.data.frame(tb)     # volver a data.frame (si se necesita)
class(df)
## [1] "data.frame"

10 Listas

Las listas son objetos heterogéneos de una dimensión. Es decir, en una lista se puede almacenar diferentes tipos de objetos (vectores, matrices, dataframes y listas) pero al igual que los vectores tienen solo una dimensión (fila o columna).

lista = list("tibble_1"=tb[1:5,],
             "tibble_2"=tb[6:10,]) # Asignar nombre a cada posición dentro de la lista
lista[[3]] = tb[11:nrow(tb),] # Almacenar en la tercera posición
lista
## $tibble_1
## # A tibble: 5 × 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  21       6   160   110  3.9   2.62  16.5     0     1     4     4
## 2  21       6   160   110  3.9   2.88  17.0     0     1     4     4
## 3  22.8     4   108    93  3.85  2.32  18.6     1     1     4     1
## 4  21.4     6   258   110  3.08  3.22  19.4     1     0     3     1
## 5  18.7     8   360   175  3.15  3.44  17.0     0     0     3     2
## 
## $tibble_2
## # A tibble: 5 × 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  18.1     6  225    105  2.76  3.46  20.2     1     0     3     1
## 2  14.3     8  360    245  3.21  3.57  15.8     0     0     3     4
## 3  24.4     4  147.    62  3.69  3.19  20       1     0     4     2
## 4  22.8     4  141.    95  3.92  3.15  22.9     1     0     4     2
## 5  19.2     6  168.   123  3.92  3.44  18.3     1     0     4     4
## 
## [[3]]
## # A tibble: 22 × 11
##      mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1  17.8     6 168.    123  3.92  3.44  18.9     1     0     4     4
##  2  16.4     8 276.    180  3.07  4.07  17.4     0     0     3     3
##  3  17.3     8 276.    180  3.07  3.73  17.6     0     0     3     3
##  4  15.2     8 276.    180  3.07  3.78  18       0     0     3     3
##  5  10.4     8 472     205  2.93  5.25  18.0     0     0     3     4
##  6  10.4     8 460     215  3     5.42  17.8     0     0     3     4
##  7  14.7     8 440     230  3.23  5.34  17.4     0     0     3     4
##  8  32.4     4  78.7    66  4.08  2.2   19.5     1     1     4     1
##  9  30.4     4  75.7    52  4.93  1.62  18.5     1     1     4     2
## 10  33.9     4  71.1    65  4.22  1.84  19.9     1     1     4     1
## # ℹ 12 more rows

10.1 Atributos

length(lista) # dimensiones
## [1] 3
names(lista) # nombres de los elementos
## [1] "tibble_1" "tibble_2" ""
names(lista)[3] = "tibble_3" # Asignar nombre al elemento 3
attributes(lista) # Ver atributos
## $names
## [1] "tibble_1" "tibble_2" "tibble_3"

10.2 Indexación

La indexación en las listas requiere dos [[]]

lista[[4]] = letters
head(lista)  
## $tibble_1
## # A tibble: 5 × 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  21       6   160   110  3.9   2.62  16.5     0     1     4     4
## 2  21       6   160   110  3.9   2.88  17.0     0     1     4     4
## 3  22.8     4   108    93  3.85  2.32  18.6     1     1     4     1
## 4  21.4     6   258   110  3.08  3.22  19.4     1     0     3     1
## 5  18.7     8   360   175  3.15  3.44  17.0     0     0     3     2
## 
## $tibble_2
## # A tibble: 5 × 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  18.1     6  225    105  2.76  3.46  20.2     1     0     3     1
## 2  14.3     8  360    245  3.21  3.57  15.8     0     0     3     4
## 3  24.4     4  147.    62  3.69  3.19  20       1     0     4     2
## 4  22.8     4  141.    95  3.92  3.15  22.9     1     0     4     2
## 5  19.2     6  168.   123  3.92  3.44  18.3     1     0     4     4
## 
## $tibble_3
## # A tibble: 22 × 11
##      mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1  17.8     6 168.    123  3.92  3.44  18.9     1     0     4     4
##  2  16.4     8 276.    180  3.07  4.07  17.4     0     0     3     3
##  3  17.3     8 276.    180  3.07  3.73  17.6     0     0     3     3
##  4  15.2     8 276.    180  3.07  3.78  18       0     0     3     3
##  5  10.4     8 472     205  2.93  5.25  18.0     0     0     3     4
##  6  10.4     8 460     215  3     5.42  17.8     0     0     3     4
##  7  14.7     8 440     230  3.23  5.34  17.4     0     0     3     4
##  8  32.4     4  78.7    66  4.08  2.2   19.5     1     1     4     1
##  9  30.4     4  75.7    52  4.93  1.62  18.5     1     1     4     2
## 10  33.9     4  71.1    65  4.22  1.84  19.9     1     1     4     1
## # ℹ 12 more rows
## 
## [[4]]
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"

10.2.1 Remover un elemento

lista = lista[-4]
head(lista)
## $tibble_1
## # A tibble: 5 × 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  21       6   160   110  3.9   2.62  16.5     0     1     4     4
## 2  21       6   160   110  3.9   2.88  17.0     0     1     4     4
## 3  22.8     4   108    93  3.85  2.32  18.6     1     1     4     1
## 4  21.4     6   258   110  3.08  3.22  19.4     1     0     3     1
## 5  18.7     8   360   175  3.15  3.44  17.0     0     0     3     2
## 
## $tibble_2
## # A tibble: 5 × 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  18.1     6  225    105  2.76  3.46  20.2     1     0     3     1
## 2  14.3     8  360    245  3.21  3.57  15.8     0     0     3     4
## 3  24.4     4  147.    62  3.69  3.19  20       1     0     4     2
## 4  22.8     4  141.    95  3.92  3.15  22.9     1     0     4     2
## 5  19.2     6  168.   123  3.92  3.44  18.3     1     0     4     4
## 
## $tibble_3
## # A tibble: 22 × 11
##      mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1  17.8     6 168.    123  3.92  3.44  18.9     1     0     4     4
##  2  16.4     8 276.    180  3.07  4.07  17.4     0     0     3     3
##  3  17.3     8 276.    180  3.07  3.73  17.6     0     0     3     3
##  4  15.2     8 276.    180  3.07  3.78  18       0     0     3     3
##  5  10.4     8 472     205  2.93  5.25  18.0     0     0     3     4
##  6  10.4     8 460     215  3     5.42  17.8     0     0     3     4
##  7  14.7     8 440     230  3.23  5.34  17.4     0     0     3     4
##  8  32.4     4  78.7    66  4.08  2.2   19.5     1     1     4     1
##  9  30.4     4  75.7    52  4.93  1.62  18.5     1     1     4     2
## 10  33.9     4  71.1    65  4.22  1.84  19.9     1     1     4     1
## # ℹ 12 more rows

10.2.2 Subset elmentos

lista[[1]] # usando la posición del elemento
## # A tibble: 5 × 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  21       6   160   110  3.9   2.62  16.5     0     1     4     4
## 2  21       6   160   110  3.9   2.88  17.0     0     1     4     4
## 3  22.8     4   108    93  3.85  2.32  18.6     1     1     4     1
## 4  21.4     6   258   110  3.08  3.22  19.4     1     0     3     1
## 5  18.7     8   360   175  3.15  3.44  17.0     0     0     3     2
lista[[1]][,"mpg"] # dentro del objeto
## # A tibble: 5 × 1
##     mpg
##   <dbl>
## 1  21  
## 2  21  
## 3  22.8
## 4  21.4
## 5  18.7
lista[["tibble_1"]] # Usando el nombre del elemento
## # A tibble: 5 × 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  21       6   160   110  3.9   2.62  16.5     0     1     4     4
## 2  21       6   160   110  3.9   2.88  17.0     0     1     4     4
## 3  22.8     4   108    93  3.85  2.32  18.6     1     1     4     1
## 4  21.4     6   258   110  3.08  3.22  19.4     1     0     3     1
## 5  18.7     8   360   175  3.15  3.44  17.0     0     0     3     2

10.3 Apilar los elementos de una lista

tbl = data.table::rbindlist(l = lista , use.names = T)
head(tbl)
##      mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##    <num> <num> <num> <num> <num> <num> <num> <num> <num> <num> <num>
## 1:  21.0     6   160   110  3.90 2.620 16.46     0     1     4     4
## 2:  21.0     6   160   110  3.90 2.875 17.02     0     1     4     4
## 3:  22.8     4   108    93  3.85 2.320 18.61     1     1     4     1
## 4:  21.4     6   258   110  3.08 3.215 19.44     1     0     3     1
## 5:  18.7     8   360   175  3.15 3.440 17.02     0     0     3     2
## 6:  18.1     6   225   105  2.76 3.460 20.22     1     0     3     1
class(tbl)
## [1] "data.table" "data.frame"

11 Directorio de trabajo

11.1 ¿Qué es un directorio de trabajo?

Es nuestra manera de decirle a R, donde debería buscar los datos que vamos a necesitar.

11.2 ¿Cómo gestionar el directorio de trabajo?

Puede pintar sobre la consola de r la ubicación del directorio de trabajo y los archivo almacenados en e directorio de trabajo:

## obtener ruta al repositorio actual
getwd() 
[1] "/Users/eduardmartinez/Library/CloudStorage/Dropbox/Teaching/Recursos R/intro-r"
## ver archivos en el directorio de trabajo
list.files() 
[1] "_extensions"       "images"            "index.html"       
[4] "index.Rmd"         "input"             "pics"             
[7] "proj.Rproj"        "segunda parte.Rmd" "styles.css"

Puede cambiar el directorio de trabajo usando la función setwd():

setwd("escribir aquí la ruta al nuevo directorio de trabajo")

11.3 ¿Qué son los proyectos?

Los proyectos son una manera alternativa de lidiar con la ruta de trabajo. Los proyectos permiten empaquetar datos y código en una especie de contenedor en el que se fija un directorio de trabajo relativo a cada equipo; haciendo más sencillo el proceso lectura y escritura de datos.

11.4 ¿Cómo crear un proyecto?

Puede crear un proyecto desde cero o puede asociar una carpeta existente a un proyecto:

11.5 Abrir un proyecto

Cuándo se abre el archivo .Rproj automáticamente Rstudio establece como directorio de trabajo la carpeta que contiene el archivo .Rproj.

## Referencias

  • W. N. Venables, D. M. Smith, 2021. An Introduction to R [Ver aquí]

    • Cap. 2: Simple manipulations; numbers and vectors
    • Cap. 3: Objects, their modes and attributes
    • Cap. 5: Arrays and matrices
    • Cap. 6: Lists and data frames

  • Colin Gillespie and Robin Lovelace, 2017. Efficient R Programming, A Practical Guide to Smarter Programming [Ver aquí]

    • Cap. 4: Efficient Workflow
    • Cap. 5: Efficient input/output